home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / TextView.C < prev    next >
C/C++ Source or Header  |  1992-08-26  |  22KB  |  984 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.     
  5. #include "TextView.h"
  6.  
  7. #include "Class.h"
  8. #include "TextCmd.h"
  9. #include "CmdNo.h"
  10. #include "String.h"
  11. #include "View.h"
  12. #include "Window.h"
  13. #include "Menu.h"
  14. #include "Error.h"
  15. #include "ChangeDialog.h"
  16. #include "Document.h"
  17. #include "RegularExp.h"
  18. #include "ClipBoard.h"
  19. #include "TextFormatter.h"
  20. #include "Env.h"
  21. #include "Data.h"
  22. #include "Math.h"
  23.  
  24. #include "SortedOList.h"
  25. #include "TextItem.h"
  26. #include "MenuBar.h"
  27.  
  28. const int cCaretHt = 4,
  29.       cCaretWd = 7;
  30.  
  31. static u_short CaretBits[]= {
  32. #   include "images/Caret.image"
  33. };
  34. SmartBitmap CaretImage(Point(cCaretWd, cCaretHt), CaretBits);
  35.  
  36. static int InputMap[] = {
  37. 0,       /* 0x00 */
  38. 0,       /* 0x01 */
  39. 0,       /* 0x02 */
  40. 0,       /* 0x03 */
  41. 0,       /* 0x04 */
  42. 0,       /* 0x05 */
  43. 0,       /* 0x06 */
  44. 0,       /* 0x07 */
  45. 0,       /* 0x08 */
  46. '\t',    /* 0x09 */
  47. '\r',    /* 0x0a */
  48. 0,       /* 0x0b */
  49. 0x0c,    /* 0x0c */
  50. '\n',    /* 0x0d */
  51. 0,       /* 0x0e */
  52. 0,       /* 0x0f */
  53. 0,       /* 0x10 */
  54. 0,       /* 0x11 */
  55. 0,       /* 0x12 */
  56. 0,       /* 0x13 */
  57. 0,       /* 0x14 */
  58. 0,       /* 0x15 */
  59. 0,       /* 0x16 */
  60. 0,       /* 0x17 */
  61. 0,       /* 0x18 */
  62. 0,       /* 0x19 */
  63. 0,       /* 0x1a */
  64. 0,       /* 0x1b */
  65. 0,       /* 0x1c */
  66. 0,       /* 0x1d */
  67. 0,       /* 0x1e */
  68. 0,       /* 0x1f */
  69. };
  70.  
  71. static int *inputmap= InputMap;
  72.  
  73. static Ink *caretColor;
  74.  
  75. void SwapSelPoints(SelPoint &p1, SelPoint &p2)
  76. {
  77.     SelPoint tmp;
  78.  
  79.     tmp= p1; p1= p2; p2= tmp;
  80. }
  81.  
  82. //----- TextView Methods -------------------------------------------------------
  83.  
  84. NewMetaImpl(TextView, StaticTextView, (TB(updateSelection), TB(inTextSelector), 
  85.     TB(enabled), TP(stopChars), TP(typing), TP(findChange), TP(scratchText), 
  86.     T(start.ch), T(start.line), T(start.viewp), T(end.ch), T(end.line), 
  87.     T(end.viewp)));
  88.  
  89. TextView::TextView(
  90.     EvtHandler *eh, Rectangle r, Text *t, 
  91.     bool w, TextViewFlags f, Point b, 
  92.     TViewAlign ta, int id
  93. ) : StaticTextView(eh, r, t, w, f, b, ta, id) 
  94. {
  95.     Init();
  96. }
  97.  
  98. void TextView::InitNew()
  99. {
  100.     View::InitNew();
  101.     inTextSelector= FALSE;
  102. }  
  103.  
  104. void TextView::Init()
  105. {
  106.     PrivSetSelection(0, 0, FALSE);
  107.     typing= 0;
  108.     stopChars= 0;
  109.     updateSelection= TRUE;
  110.     text->AddObserver(this);
  111.     scratchText= text->MakeScratchText(0, cMaxBatchedIns);
  112.     findChange= 0;
  113.     active= TRUE;
  114.     inTextSelector= FALSE;
  115.     enabled= FALSE;
  116.     if (Env::GetValue("TextView.DragAndDrop", TRUE))
  117.     SetFlag(eTextViewDragAndDrop);
  118.     SetFlag(eVObjKbdFocus);
  119. }
  120.  
  121. TextView::~TextView()
  122. {
  123.     if (text)
  124.     text->RemoveObserver(this);
  125.     SafeDelete(stopChars);
  126.     if (findChange)
  127.     findChange->Close();
  128.     SafeDelete(findChange);
  129.     SafeDelete(scratchText);
  130. }
  131.  
  132. void TextView::InvalidateSelection()
  133. {
  134.     if (AnySelection())
  135.     InvalidateRange(start.line, start.viewp, end.line, end.viewp);
  136. }
  137.  
  138. void TextView::Draw(Rectangle r)
  139. {
  140.     if (GrHasColor() && CanShowSelection() && AnySelection())
  141.     Invert(start.line, start.viewp, end.line, end.viewp);
  142.     StaticTextView::Draw(r);
  143.     if (CanShowSelection() && AnySelection()) {
  144.     DrawCaret(start.viewp, start.line, On);
  145.     if (!GrHasColor())
  146.         Invert(start.line, start.viewp, end.line, end.viewp);
  147.     }
  148. }
  149.     
  150. void TextView::DrawCaret(Point p, int line, HighlightState)
  151. {
  152.     if (! inTextSelector && AnySelection() && Caret()) {
  153.     int bh= BaseHeight(line);
  154.     p+= GetInnerOrigin();
  155.  
  156.     if (caretColor == 0) {
  157.         if (GrHasColor()) {
  158.         caretColor= new_RGBColor(255, 0, 0);
  159.         //Env::Bind(caretColor, "TextView.CaretColor");
  160.         } else
  161.         caretColor= ePatXor;
  162.     }
  163.     
  164.     if (LineHeight(line) - bh >= cCaretHt) {
  165.         Rectangle r(p.x-cCaretHt, p.y+bh, cCaretWd, cCaretHt);
  166.         GrPaintBitMap(r, CaretImage, caretColor);
  167.     }
  168.     p.x--;
  169.     GrPaintLine(caretColor, 0, eDefaultCap, p, Point(p.x, p.y+bh));
  170.     }
  171. }
  172.  
  173. void TextView::SetKeyMap(int *map)
  174. {
  175.     inputmap= map;
  176. }
  177.  
  178. //---- highlight the characters in the given range -----------------------
  179.  
  180. void TextView::Invert(int from, Point fp, int to, Point tp)
  181. {
  182.     if (AnySelection() && !Caret()) {
  183.     Rectangle r;
  184.     Ink *c= gHighlightColor;
  185.     
  186.     if ((from == to && fp.x > tp.x) || from > to) { // normalize range
  187.         SwapRange(from, to);
  188.         Swap(fp, tp);   
  189.     }
  190.     
  191.     if (from == to) {
  192.         r= Rectangle(LineToPoint(from)+Point (fp.x,0),
  193.                Point(tp.x-fp.x, LineHeight(from)));
  194.         GrPaintRect(r+GetInnerOrigin(), c);
  195.         return;
  196.     }
  197.     r= Rectangle(LineToPoint(from)+ Point(fp.x,0),
  198.               Point(GetInnerExtent().x-fp.x, LineHeight(from)));
  199.     GrPaintRect(r+GetInnerOrigin(), c);
  200.     r= Rectangle(LineToPoint(from + 1), Point(GetInnerExtent().x,
  201.               LineToPoint(to).y - LineToPoint(from + 1).y));
  202.     GrPaintRect(r+GetInnerOrigin(), c);
  203.     r= Rectangle(LineToPoint(to), Point(tp.x, LineHeight(to)));
  204.     GrPaintRect(r+GetInnerOrigin(), c);
  205.     }
  206. }
  207.  
  208. void TextView::RepairAll()
  209. {
  210.     StaticTextView::RepairAll();
  211.     if (CanShowSelection())
  212.     SetSelection(start.ch, end.ch, FALSE);
  213. }
  214.  
  215. void TextView::ClearSelection(bool redraw)
  216. {
  217.     if (AnySelection()) {
  218.     InvalidateSelection();
  219.     start.ch= end.ch= -1;
  220.     if (redraw)
  221.         UpdateEvent();
  222.     }
  223. }
  224.  
  225. void TextView::ShowSelection(bool redraw, bool show)
  226. {
  227.     if (enabled != show) {
  228.     enabled= show;
  229.     InvalidateSelection();
  230.     if (redraw)
  231.         UpdateEvent();
  232.     }
  233. }
  234.  
  235. bool TextView::KbdFocus(bool in)
  236. {
  237.     ShowSelection(FALSE, in);
  238.     return TRUE;
  239. }
  240.  
  241. void TextView::Enable(bool enable, bool redraw)
  242. {
  243.     StaticTextView::Enable(enable, redraw);
  244.     if (! enable)
  245.     HideSelection(redraw);
  246. } 
  247.  
  248. void TextView::PrivSetSelection(SelPoint s, SelPoint e, bool redraw)
  249. {
  250.     InvalidateSelection();          // invalidate old selection
  251.     start= s;
  252.     end= e;
  253.     InvalidateSelection();          // invalidate new selection
  254.     if (redraw)
  255.     UpdateEvent();
  256.     Send(GetId(), cPartSelectionChanged, this);
  257. }
  258.  
  259. void TextView::PrivSetSelection(int s, int e, bool redraw)
  260. {
  261.     SelPoint sp, ep;
  262.  
  263.     if (text == 0)
  264.     return;
  265.     
  266.     int end= text->End();
  267.     sp.ch= Math::Range(0, end, s);
  268.     ep.ch= Math::Range(0, end, e);
  269.     sp.ch= CharToPoint(sp.ch, &sp.line, &sp.viewp);
  270.     if (sp.ch != ep.ch)
  271.     ep.ch= CharToPoint(ep.ch, &ep.line, &ep.viewp);
  272.     else
  273.     ep= sp;
  274.     PrivSetSelection(sp, ep, redraw);
  275. }
  276.  
  277. void TextView::SetSelection(int s, int e, bool redraw)
  278. {
  279.     DoneTyping();
  280.     PrivSetSelection(s, e, FALSE);
  281.     ShowSelection(redraw);
  282. }
  283.  
  284. void TextView::SelectionAsString(byte *buf, int ma)
  285. {
  286.     GetText()->CopyInStr(buf, ma, start.ch, end.ch);
  287. }
  288.  
  289. Text *TextView::SelectionAsText()
  290. {
  291.     return text->Save(start.ch, end.ch);
  292. }
  293.  
  294. void TextView::SetDragAndDrop(bool on)
  295. {
  296.     SetFlag(eTextViewDragAndDrop, on);
  297. }
  298.  
  299. Rectangle TextView::BoundingRect(int from, int to)
  300. {
  301.     Point sp, ep;
  302.     int sl, el;
  303.     
  304.     if(from == start.ch) {
  305.     sp= start.viewp;
  306.     sl= start.line;
  307.     } else 
  308.     CharToPoint(from, &sl, &sp);
  309.     if (to == end.ch) {
  310.     ep= end.viewp;
  311.     el= end.line;
  312.     } else
  313.     CharToPoint(to, &el, &ep);
  314.  
  315.     Point rp(ep.x+1, ep.y + LineHeight(el));
  316.     Rectangle r= NormRect(sp, rp);
  317.     r.origin+= GetInnerOrigin();
  318.     return r;
  319. }
  320.  
  321. void TextView::RevealSelection()
  322. {
  323.     if (AnySelection()) {
  324.     Rectangle r= SelectionRect().Expand(Point(8,0));
  325.     RevealRect(r, r.extent);
  326.     }
  327. }
  328.      
  329. Rectangle TextView::SelectionRect()
  330. {
  331.     if (AnySelection()) 
  332.     return BoundingRect(start.ch, end.ch);
  333.     return gRect0;
  334. }
  335.  
  336. Command *TextView::DoLeftButtonDownCommand(Point lp, Token t, int clicks)
  337. {
  338.     SelPoint oldStart, oldEnd;
  339.     TextRangeFP rf= CharacterRange;
  340.     
  341.     oldStart= start;
  342.     oldEnd= end;
  343.  
  344.     if (! Enabled())
  345.     return View::DoLeftButtonDownCommand(lp, t, clicks);
  346.     
  347.     if (clicks >= 3)
  348.     rf= ParagraphRange;
  349.     else if (clicks >= 2) 
  350.     rf= WordRange;
  351.  
  352.     if (t.Flags == eFlgShiftKey) 
  353.     return new ExtendRangeSelector(this, rf);  
  354.     
  355.     if (clicks == 1) {
  356.     if (TestFlag(eTextViewDragAndDrop)) {
  357.         SelPoint n;
  358.         PointToPoint(lp-GetInnerOrigin(), &n.viewp, &n.line, &n.ch);
  359.         if (n.ch >= oldStart.ch && n.ch < oldEnd.ch)
  360.         return new DragAndDropSelector(this, oldStart.ch, oldEnd.ch, t.Flags == eFlgCntlKey);
  361.     }     
  362.     if (t.Flags == eFlgCntlKey) 
  363.         return new DragAndDropSelector(this, oldStart.ch, oldEnd.ch, TRUE); 
  364.  
  365.     if (t.Flags == (eFlgShiftKey|eFlgCntlKey))
  366.         return new QuickPasteSelector(this, oldStart.ch, oldEnd.ch);
  367.     }
  368.     if (t.Flags == 0)
  369.     return new RangeSelector(this, rf);
  370.     return View::DoLeftButtonDownCommand(lp, t, clicks);
  371. }
  372.  
  373. void TextView::SetStopChars(char *stops)
  374. {
  375.     strreplace(&stopChars, stops);
  376. }
  377.  
  378. Command *TextView::DoKeyCommand(int ch, Token)
  379. {
  380.     int nDelete= 0;
  381.     Token t;
  382.     bool newCmd, delSelection;       // delete the selection only
  383.  
  384.     if (! Writeable())
  385.     return gNoChanges;
  386.  
  387.     GrSetCursor(eCrsNone);
  388.     
  389.     if (ch != '\b' && Iscntrl(ch))
  390.     ch= inputmap[ch];
  391.     
  392.     newCmd= (typing == 0); // start new typing sequence?
  393.  
  394.     if (newCmd)
  395.     typing= MakeTypingCommand(cTYPEING, "Typing");
  396.  
  397.     delSelection= (newCmd && !Caret());
  398.     if (ch != '\b' || delSelection) {     
  399.     for (;;) {
  400.         if (ch != '\b' && ch != '\0') {
  401.         typing->AddChar();
  402.         scratchText->Append(ch);
  403.         }
  404.         if (scratchText->Size() == cMaxBatchedIns)
  405.         break;
  406.         gWindow->ReadEvent(t, 0);
  407.         if (t.IsAscii() && (byte)t.Code != '\b' 
  408.         // do not batch stopChars
  409.         && !(stopChars && strchr(stopChars, (byte)t.Code)) 
  410.         && ! TestFlag(eTextViewNoBatch)) {
  411.         ch= (byte) t.Code;
  412.         if (ch != '\b' && Iscntrl(ch)) 
  413.             ch= inputmap[ch];
  414.         } else {
  415.         if (t.Code != eEvtNone)
  416.             gWindow->PushBackEvent(t);
  417.         break;
  418.         } 
  419.     }
  420.     Paste(scratchText);
  421.     scratchText->Empty();
  422.     } else {
  423.     for (;;) {
  424.         typing->DelChar();
  425.         nDelete++;
  426.         gWindow->ReadEvent(t, 0);
  427.         if ((byte) t.Code != '\b') {
  428.         gWindow->PushBackEvent(t);
  429.         break;
  430.         }
  431.     }
  432.     DelChar(nDelete);
  433.     }
  434.     RevealSelection();
  435.     if (newCmd)
  436.     return typing;
  437.     return gNoChanges;
  438. }
  439.  
  440. Command *TextView::DoCursorKeyCommand(EvtCursorDir cd, Token)
  441. {
  442.     Point p;
  443.     int charNo= 0;
  444.  
  445.     if (! Enabled())
  446.     return gNoChanges;
  447.     switch (cd) {
  448.     case eCrsLeft:
  449.     charNo= start.ch-1;
  450.     break;
  451.     case eCrsRight:
  452.     charNo= end.ch+1;
  453.     break;
  454.     case eCrsUp:
  455.     charNo= CursorPos(start.ch, start.line, cd, p);
  456.     break;
  457.     case eCrsDown:
  458.     charNo= CursorPos(end.ch, end.line, cd, p);
  459.     break;
  460.     }
  461.     PrivSetSelection(charNo, charNo);
  462.     DoneTyping();
  463.     RevealSelection();
  464.     return gNoChanges;
  465. }
  466.  
  467. int TextView::CursorPos(int at, int line, EvtCursorDir d, Point p)
  468. {
  469.     int charNo;
  470.     Point basePoint, screenPoint;
  471.  
  472.     CharToPoint(at, &line, &screenPoint);
  473.     if (d == eCrsDown)
  474.     line= Math::Min(nLines-1, line+1);
  475.     else
  476.     line= Math::Max(0, line-1);        
  477.     basePoint= LineToPoint(line, TRUE) + Point(screenPoint.x, 0);
  478.     PointToPoint(basePoint, &p, &line, &charNo);
  479.     return charNo;
  480. }
  481.  
  482. GrCursor TextView::GetCursor(Point lp)
  483. {
  484.     if (TestFlag(eTextViewDragAndDrop)) {
  485.     SelPoint n;
  486.     PointToPoint(lp-GetInnerOrigin(), &n.viewp, &n.line, &n.ch);
  487.     if (n.ch >= start.ch && n.ch < end.ch) 
  488.         return eCrsBoldArrow;
  489.     }
  490.     return eCrsIBeam;
  491. }
  492.  
  493. void TextView::DoneTyping()
  494. {
  495.     typing= 0;
  496.     text->ResetCurrentCharStyle();
  497. }
  498.  
  499. void TextView::TypingDeleted(TypingCommand *t)
  500. {
  501.     if (t == typing)
  502.     typing= 0;
  503. }
  504.  
  505. TypingCommand *TextView::MakeTypingCommand(int cmdNo, char *name)
  506. {
  507.     return new TypingCommand(this, cmdNo, name);
  508. }
  509.  
  510. bool TextView::DeleteRequest(int,int)
  511. {
  512.     return TRUE;
  513. }
  514.  
  515. void TextView::Cut()
  516. {
  517.     if (!Writeable())
  518.     return; 
  519.     if (DeleteRequest(start.ch, end.ch) && AnySelection()) {
  520.     updateSelection= FALSE;
  521.     text->Cut(start.ch, end.ch);
  522.     updateSelection= TRUE;
  523.     PrivSetSelection(start.ch, start.ch, FALSE);
  524.     }
  525. }
  526.  
  527. void TextView::Copy(Text *t)
  528. {
  529.     text->Copy(t, start.ch, end.ch);
  530. }
  531.  
  532. void TextView::Paste(Text *t)
  533. { 
  534.     if (!Writeable())
  535.     return;
  536.     if ((!Caret() && !DeleteRequest(start.ch, end.ch)) || !AnySelection())
  537.     return;
  538.     updateSelection= FALSE;
  539.     text->Paste(t, start.ch, end.ch);
  540.     updateSelection= TRUE;
  541.     PrivSetSelection(start.ch+t->End(), start.ch+t->End(), FALSE);       
  542. }
  543.  
  544. Command *TextView::InsertText(Text *t)
  545. {
  546.     if (!Writeable())
  547.     return gNoChanges;
  548.  
  549.     bool newCmd= (typing == 0); // start new typing sequence?
  550.  
  551.     if (newCmd)
  552.     typing= MakeTypingCommand(cTYPEING, "Typing");
  553.  
  554.     typing->AddChar(t->End());
  555.     Paste(t);
  556.     if (newCmd)
  557.     return typing;
  558.     return gNoChanges;
  559. }
  560.  
  561. Command *TextView::InsertString(byte *str, int len)
  562. {
  563.     Text *t= text->MakeScratchText(str, len);
  564.     Command *cmd= InsertText(t);
  565.     SafeDelete(t);
  566.     return cmd;
  567. }
  568.  
  569. void TextView::DelChar(int n)
  570. {
  571.     int newStart= Math::Max(0, start.ch-n);
  572.     int changedLine= CharToLine(newStart);
  573.  
  574.     if (newStart == start.ch)
  575.     return;
  576.     if (newStart == 0 && start.ch == 0)
  577.     return;
  578.     if (DeleteRequest(newStart, start.ch)) {
  579.     updateSelection= FALSE;   
  580.     text->Cut(newStart, start.ch);
  581.     updateSelection= TRUE;
  582.     PrivSetSelection(newStart, newStart, FALSE);       
  583.     }
  584. }
  585.  
  586. Text *TextView::SetText(Text *t, bool scroll)
  587. {
  588.     Text *old= text;
  589.     SetFlag(eTextViewModified);
  590.     ForceRedraw();
  591.     old->RemoveObserver(this);
  592.     PrivSetSelection(0, 0, FALSE); // reset old selection
  593.     text= t;    
  594.     SafeDelete(scratchText);
  595.     scratchText= text->MakeScratchText(0, cMaxBatchedIns);
  596.     text->AddObserver(this);
  597.     RepairAll();
  598.     if (scroll == cRevealTop)
  599.     Scroll(cPartScrollAbs, gPoint0, FALSE);
  600.     Send(GetId(), cPartReplacedText, 0);
  601.     PrivSetSelection(0, 0, FALSE); // set new selection
  602.     typing= 0;
  603.     return old;
  604. }       
  605.  
  606. void TextView::SetString(byte *str, int len)
  607. {
  608.     ForceRedraw();
  609.     PrivSetSelection(0, 0, FALSE);
  610.     text->ReplaceWithStr(str, len);
  611.     RepairAll();
  612.     Send(GetId(), cPartReplacedText, 0);
  613.     DoneTyping();
  614.     PrivSetSelection(0, 0, FALSE);
  615.     typing= 0;
  616. }
  617.  
  618. void TextView::SetReadOnly(bool m)
  619. {
  620.     SetFlag(eTextViewReadOnly, m);
  621. }
  622.  
  623. bool TextView::GetReadOnly()
  624. { 
  625.     return TestFlag(eTextViewReadOnly); 
  626. }
  627.  
  628. void TextView::DoObserve(int, int part, void *what, Object *op)
  629. {
  630.     int d= 0, d1= 0;
  631.     
  632.     if (op == text && part == cPartSenderDied) {
  633.     text= 0;
  634.     return;    
  635.     }
  636.     
  637.     if (op == text) {
  638.     TextChanges tc= *(TextChanges*)what;
  639.     SetFlag(eTextViewModified);
  640.     switch (part) {
  641.     case eTextChangedRange:
  642.         marks->RangeChanged(tc.from, tc.to - tc.from);
  643.         Repair(tc.from, tc.to, FALSE);
  644.         if (updateSelection && AnySelection())
  645.         PrivSetSelection(tc.from, tc.to, TRUE);
  646.         break;
  647.  
  648.     case eTextDeleted:
  649.     case eTextReplaced:
  650.         marks->Replace(tc.from, tc.to, tc.size);
  651.         Repair(tc.from, tc.from+tc.size, FALSE);
  652.         if (updateSelection && AnySelection()) {
  653.         int p= tc.from+tc.size;
  654.         PrivSetSelection(p, p, TRUE);
  655.         }
  656.         break;
  657.     }
  658.     if (tc.pagination == cPaginationChange) 
  659.         ForceRedraw();
  660.     Send(GetId(), cPartChangedText, this);    // notify observers of the textview   
  661.     }
  662. }
  663.  
  664. bool TextView::PrintOnWhenObserving(Object *from)
  665. {
  666.     return GetText() != from;
  667. }
  668.  
  669. IStream& TextView::ReadFrom(IStream &s)
  670. {
  671.     StaticTextView::ReadFrom(s);
  672.     enabled= TRUE;
  673.     GetText()->AddObserver(this);
  674.     scratchText= text->MakeScratchText(0, cMaxBatchedIns);
  675.     return s;
  676. }
  677.  
  678. void TextView::NormSelection()
  679. {
  680.     if (start.ch > end.ch) 
  681.     SwapSelPoints(start, end);
  682. }
  683.  
  684. //---- menu related commands -----------------------------------------------
  685.  
  686. bool TextView::HasSelection()
  687. {
  688.     return AnySelection() && !Caret();
  689. }
  690.  
  691. Command *TextView::PasteData(Data *data)
  692. {
  693.     Text *t;
  694.     if (t= (Text*) data->AsObject(GetText()->IsA()))
  695.     return new PasteCommand(this, t);
  696.     return gNoChanges;
  697. }
  698.  
  699. bool TextView::CanPaste(Data *data)
  700. {
  701.     return data->CanConvert(GetText()->IsA());
  702. }
  703.  
  704. Menu *TextView::MakeMenu(int menuId)
  705. {
  706.     int font, size= gSysFont->Size();
  707.     GrFont fid= (GrFont)gSysFont->Fid();
  708.     char *fontname;
  709.     Menu *m;
  710.     
  711.     switch (menuId) {
  712.     case cFONTMENU:
  713.     m= new Menu(cFONTMENU, "Fonts", FALSE, TRUE, 0, 1, new SortedObjList);
  714.     for (font= 0; fontname= gFontManager->IdToName((GrFont)font); font++)
  715.         m->AppendItem(fontname, cFIRSTFONT+font);
  716.     break;
  717.         
  718.     case cSTYLEMENU:
  719.     m= new Menu(cSTYLEMENU, "Styles", FALSE);
  720.     m->Append(new MenuButtonItem(cFIRSTFACE+eFacePlain, 
  721.         new TextItem("Plain", new_Font(fid, size, eFacePlain))));
  722.     m->Append(new MenuButtonItem(cFIRSTFACE+eFaceBold,
  723.         new TextItem("Bold", new_Font(fid, size, eFaceBold)), "B"));
  724.     m->Append(new MenuButtonItem(cFIRSTFACE+eFaceItalic,
  725.         new TextItem("Italic", new_Font(fid, size, eFaceItalic)), "I"));
  726.     m->Append(new MenuButtonItem(cFIRSTFACE+eFaceUnderline,
  727.         new TextItem("Underline", new_Font(fid, size, eFaceUnderline)), "U"));
  728.     m->Append(new MenuButtonItem(cFIRSTFACE+eFaceOutline,
  729.         new TextItem("Outline", new_Font(fid, size, eFaceOutline))));
  730.     m->Append(new MenuButtonItem(cFIRSTFACE+eFaceShadow,
  731.         new TextItem("Shadow", new_Font(fid, size, eFaceShadow))));
  732.     break;
  733.     
  734.     case cSIZEMENU:
  735.     m= new Menu(cSIZEMENU, "Sizes", FALSE);
  736.     for (int sz= 9; sz <= 24; sz++)
  737.         m->AppendItem(form("%d  Points", sz), cFIRSTSIZE+sz); 
  738.     break;
  739.     
  740.     case cFORMATMENU:
  741.     m= new Menu(cFORMATMENU, "Format", FALSE);
  742.     m->Append(new MenuButtonItem(cFIRSTADJUST,   "Align Left"));
  743.     m->Append(new MenuButtonItem(cFIRSTADJUST+1, "Align Right"));
  744.     m->Append(new MenuButtonItem(cFIRSTADJUST+2, "Align Center"));
  745.     m->Append(new MenuButtonItem(cFIRSTADJUST+3, "Justify"));
  746.     m->AppendItems("-", 0);
  747.     m->Append(new MenuButtonItem(cFIRSTSPACING+0, "Single Spacing"));
  748.     m->Append(new MenuButtonItem(cFIRSTSPACING+18, "1-1/2 Spacing"));
  749.     m->Append(new MenuButtonItem(cFIRSTSPACING+24, "Double Spacing"));
  750.     break;
  751.     
  752.     }
  753.     return m;
  754. }
  755.  
  756. void TextView::DoSetupMenu(Menu *m)
  757. {    
  758.     View::DoSetupMenu(m);
  759.     switch (m->GetId()) {
  760.     case cEDITMENU:
  761.     SetupEditMenu(m);
  762.     break;
  763.     case cSIZEMENU:
  764.     SetupSizeMenu(m);
  765.     break;
  766.     case cFONTMENU:
  767.     SetupFontMenu(m);
  768.     break;
  769.     case cFORMATMENU:
  770.     SetupFormatMenu(m);
  771.     break;
  772.     case cSTYLEMENU:
  773.     SetupCharStyleMenu(m);
  774.     break;
  775.     case cVIEWMENU:
  776.     SetupViewMenu(m);
  777.     break;
  778.     }
  779. }
  780.  
  781. void TextView::SetupEditMenu(Menu *m)
  782. {
  783.     if (!GetReadOnly() && !Caret()) 
  784.     m->EnableItems(cCUT, cIMPORT, 0);
  785.     if (AnySelection())
  786.     m->EnableItems(cSELECTALL, cFIND, 0);
  787. }
  788.  
  789. void TextView::SetupSizeMenu(Menu *m)
  790. {
  791.     Font *fp= GetCharStyle()->GetFont();
  792.     m->CheckItem(cFIRSTSIZE+fp->Size());
  793. }
  794.  
  795. void TextView::SetupFontMenu(Menu *m)
  796. {
  797.     Font *fp= GetCharStyle()->GetFont();
  798.     m->CheckItem(gFontManager->NameToId(fp->Name())+cFIRSTFONT);
  799. }
  800.  
  801. void TextView::SetupViewMenu(Menu *m)
  802. {
  803.     m->EnableItem(cSHOWINVIS);
  804.     m->CheckItem(cSHOWINVIS, GetShowInvis(), cItemStateManyOf);
  805. }
  806.  
  807. void TextView::SetupCharStyleMenu(Menu *m)
  808. {
  809.     GrFace face= GetCharStyle()->GetFont()->Face();
  810.     m->CheckItem(cFIRSTFACE+eFacePlain, face == eFacePlain);
  811.     m->CheckItem(cFIRSTFACE+eFaceBold, (face&eFaceBold) == eFaceBold, cItemStateManyOf);
  812.     m->CheckItem(cFIRSTFACE+eFaceItalic, (face&eFaceItalic) == eFaceItalic, cItemStateManyOf);
  813.     m->CheckItem(cFIRSTFACE+eFaceUnderline, (face&eFaceUnderline) == eFaceUnderline, cItemStateManyOf);
  814.     m->CheckItem(cFIRSTFACE+eFaceOutline, (face&eFaceOutline) == eFaceOutline, cItemStateManyOf);
  815.     m->CheckItem(cFIRSTFACE+eFaceShadow, (face&eFaceShadow) == eFaceShadow, cItemStateManyOf);        
  816. }
  817.       
  818. void TextView::SetupFormatMenu(Menu *m)
  819. {
  820.     int from, to;
  821.     GetSelection(&from, &to);
  822.     ParaStyle *ps= text->GetParaStyle(from);
  823.     m->CheckItem(ps->GetProperty(eTxtPAlign)+cFIRSTADJUST);
  824.     m->CheckItem(ps->GetProperty(eTxtPSpacing)+cFIRSTSPACING);
  825. } 
  826.  
  827. Command *SetParaProp(TextView *view, int cmd, TxtParaProp p, int value)
  828. {
  829.     ParaDesc pd;
  830.     pd.SetProperty(p, value);
  831.     return 
  832.     new ParaStyleCommand(
  833.         view,
  834.         cmd,
  835.         "Change Formatting",
  836.         p,
  837.         pd
  838.     );
  839. }
  840.  
  841. Command *TextView::DoMenuCommand(int cmd)
  842. {
  843.     if (cmd >= cFIRSTSIZE && cmd <= cLASTSIZE) 
  844.     return new CharStyleCommand(
  845.             this, 
  846.             cmd, 
  847.             "Change Size", 
  848.             eTxtPSize, 
  849.             CharStyleSpec(
  850.                 eFontDefault, 
  851.                 eFacePlain,
  852.                 (GrFace)(cmd-cFIRSTSIZE)
  853.             )
  854.     );
  855.  
  856.     if (cmd >= cFIRSTFONT && cmd <= cLASTFONT) 
  857.     return new CharStyleCommand(
  858.             this, 
  859.             cmd, 
  860.             "Change Font", 
  861.             eTxTPFont, 
  862.             CharStyleSpec(
  863.                 (GrFont)(cmd-cFIRSTFONT),
  864.                 eFacePlain,
  865.                 0
  866.             )
  867.     );
  868.     
  869.     if (cmd >= cFIRSTFACE && cmd <= cLASTFACE) {
  870.     return new CharStyleCommand(
  871.             this, 
  872.             cmd, 
  873.             "Change Face",
  874.             eTxTPFace, 
  875.             CharStyleSpec(
  876.                 eFontDefault,
  877.                 (GrFace)(cmd-cFIRSTFACE),
  878.                 0
  879.             )
  880.     );
  881.     }
  882.  
  883.     if (cmd >= cFIRSTSPACING && cmd <= cLASTSPACING) {
  884.     ParaDesc pd;
  885.     pd.SetProperty(eTxtPSpacing, cmd-cFIRSTSPACING);
  886.     return 
  887.         new ParaStyleCommand(
  888.         this,
  889.         cmd,
  890.         "Change Formatting",
  891.         eTxtPSpacing,
  892.         pd
  893.         );
  894.     }
  895.  
  896.     /*
  897.     if (cmd >= cFIRSTCOLOR && cmd <= cLASTCOLOR) 
  898.     return new CharStyleCommand(
  899.             this, 
  900.             cmd, 
  901.             "Change Color",
  902.             eTxtPInk, 
  903.             CharStyleSpec(
  904.                 eFontDefault,
  905.                 eFacePlain,
  906.                 0,
  907.                 palette[cmd-cFIRSTCOLOR]
  908.             )
  909.     );
  910.     */
  911.     
  912.     if (cmd >= cFIRSTADJUST && cmd <= cLASTADJUST) 
  913.     return SetParaProp(this, cmd, eTxtPAlign, cmd-cFIRSTADJUST); 
  914.     
  915.     switch (cmd) {
  916.     case cCUT:
  917.     case cCOPY:
  918.     gClipBoard->SelectionToClipboard(SelectionAsText(), FALSE);
  919.     return new CutCopyCommand(this, cmd);
  920.     
  921.     case cSELECTALL:
  922.     SelectAll();
  923.     break;
  924.     
  925.     case cSHOWINVIS:
  926.     ShowInvisibles(!GetShowInvis());
  927.     return gNoChanges;
  928.     
  929.     default:
  930.     return View::DoMenuCommand(cmd);
  931.     }
  932.     return gNoChanges;
  933. }
  934.  
  935. bool TextView::SelectRegExpr(RegularExp *rex, bool dir)
  936. {
  937.     int selStart, selEnd, pos, matched;
  938.  
  939.     GetSelection(&selStart, &selEnd);
  940.     if (dir == cSearchForward)
  941.     pos= GetText()->Search(rex, &matched, selEnd);
  942.     else
  943.     pos= GetText()->Search(rex, &matched, Math::Max(0, selStart-1), cMaxInt, FALSE);
  944.  
  945.     if (pos != -1) {
  946.     PrivSetSelection(pos, pos+matched);
  947.     DoneTyping();
  948.     return TRUE;
  949.     }
  950.     return FALSE;
  951. }
  952.  
  953. void TextView::Home()
  954. {
  955.     PrivSetSelection(0, 0);
  956.     DoneTyping();
  957. }
  958.  
  959. void TextView::Bottom()
  960. {
  961.     PrivSetSelection(cMaxInt, cMaxInt);
  962.     DoneTyping();
  963. }
  964.  
  965. void TextView::SelectAll(bool redraw)
  966. {
  967.     PrivSetSelection(0, text->End(), redraw);
  968.     DoneTyping();
  969. }
  970.  
  971. CharStyle *TextView::GetCharStyle()
  972. {
  973.     int from, to;
  974.     GetSelection(&from, &to);
  975.     if (text->GetCurrentCharStyle())
  976.     return text->GetCurrentCharStyle();
  977.     else if (text->IsParaStart(from))
  978.     from++;
  979.     if (from == to)
  980.     from--;
  981.     return text->GetCharStyle(Math::Max(0, from));
  982. }
  983.  
  984.